home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 1999 #2 / Amiga Plus CD - 1999 - No. 2.iso / System-Boost / Workbench / ToolManager / Source / Prefs / sound.c < prev    next >
C/C++ Source or Header  |  1998-06-17  |  10KB  |  323 lines
  1. /*
  2.  * sound.c  V3.1
  3.  *
  4.  * TM Sound object class
  5.  *
  6.  * Copyright (C) 1990-98 Stefan Becker
  7.  *
  8.  * This source code is for educational purposes only. You may study it
  9.  * and copy ideas or algorithms from it for your own projects. It is
  10.  * not allowed to use any of the source codes (in full or in parts)
  11.  * in other programs. Especially it is not allowed to create variants
  12.  * of ToolManager or ToolManager-like programs from this source code.
  13.  *
  14.  */
  15.  
  16. #include "toolmanager.h"
  17.  
  18. /* Local data */
  19. #define PROPCHUNKS 4
  20. static const ULONG PropChunkTable[2 * PROPCHUNKS] = {
  21.  ID_TMSO, ID_CMND,
  22.  ID_TMSO, ID_DATA,
  23.  ID_TMSO, ID_NAME,
  24.  ID_TMSO, ID_PORT,
  25. };
  26. static const char *TextTitle;
  27. static const char *HelpCommand;
  28. static const char *TextARexxPort;
  29. static const char *HelpARexxPort;
  30.  
  31. /* Sound class instance data */
  32. struct SoundClassData {
  33.  const char *scd_Command;
  34.  const char *scd_ARexxPort;
  35.  Object     *scd_Active;
  36.  Object     *scd_CmdString;
  37.  Object     *scd_PopPort;
  38. };
  39. #define TYPED_INST_DATA(cl, o) ((struct SoundClassData *) INST_DATA((cl), (o)))
  40.  
  41. /* Sound class method: OM_NEW */
  42. #undef  DEBUGFUNCTION
  43. #define DEBUGFUNCTION SoundClassNew
  44. static ULONG SoundClassNew(Class *cl, Object *obj, struct opSet *ops)
  45. {
  46.  SOUND_LOG((LOG1(Tags, "0x%08lx", ops->ops_AttrList),
  47.             PrintTagList(ops->ops_AttrList)))
  48.  
  49.  /* Create object */
  50.  if (obj = (Object *) DoSuperNew(cl, obj,
  51.                                        MUIA_Window_Title, TextTitle,
  52.                                        MUIA_HelpNode,     "SoundWindow",
  53.                                        TMA_Type,          TMOBJTYPE_SOUND,
  54.                                        TAG_MORE,          ops->ops_AttrList)) {
  55.   struct SoundClassData *scd = TYPED_INST_DATA(cl, obj);
  56.  
  57.   /* Initialize instance data */
  58.   scd->scd_Command   = NULL;
  59.   scd->scd_ARexxPort = NULL;
  60.   scd->scd_Active    = NULL;
  61.  }
  62.  
  63.  SOUND_LOG(LOG1(Result, "0x%08lx", obj))
  64.  
  65.  /* Return pointer to created object */
  66.  return((ULONG) obj);
  67. }
  68.  
  69. /* Sound class method: OM_DISPOSE */
  70. #undef  DEBUGFUNCTION
  71. #define DEBUGFUNCTION SoundClassDispose
  72. static ULONG SoundClassDispose(Class *cl, Object *obj, Msg msg)
  73. {
  74.  struct SoundClassData *scd = TYPED_INST_DATA(cl, obj);
  75.  
  76.  SOUND_LOG(LOG1(Disposing, "0x%08lx", obj))
  77.  
  78.  /* Free instance data */
  79.  if (scd->scd_Command)   FreeVector(scd->scd_Command);
  80.  if (scd->scd_ARexxPort) FreeVector(scd->scd_ARexxPort);
  81.  
  82.  /* Call SuperClass */
  83.  return(DoSuperMethodA(cl, obj, msg));
  84. }
  85.  
  86. /* Sound class method: TMM_Finish */
  87. #undef  DEBUGFUNCTION
  88. #define DEBUGFUNCTION SoundClassFinish
  89. static ULONG SoundClassFinish(Class *cl, Object *obj, struct TMP_Finish *tmpf)
  90. {
  91.  struct SoundClassData *scd = TYPED_INST_DATA(cl, obj);
  92.  
  93.  SOUND_LOG(LOG1(Type, "%ld", tmpf->tmpf_Type))
  94.  
  95.  /* MUI objects allocated? */
  96.  if (scd->scd_Active) {
  97.  
  98.   /* Use or Cancel? */
  99.   if (tmpf->tmpf_Type == TMV_Finish_Use) {
  100.  
  101.    /* Get new string contents */
  102.    scd->scd_Command   = GetStringContents(scd->scd_CmdString,
  103.                                           scd->scd_Command);
  104.    scd->scd_ARexxPort = GetStringContents(scd->scd_PopPort,
  105.                                           scd->scd_ARexxPort);
  106.   }
  107.  
  108.   /* Reset pointer to file name area */
  109.   scd->scd_Active = NULL;
  110.  }
  111.  
  112.  /* Call SuperClass */
  113.  return(DoSuperMethodA(cl, obj, (Msg) tmpf));
  114. }
  115.  
  116. /* Sound class method: TMM_Edit */
  117. #undef  DEBUGFUNCTION
  118. #define DEBUGFUNCTION SoundClassEdit
  119. static ULONG SoundClassEdit(Class *cl, Object *obj, struct TMP_Edit *tmpe)
  120. {
  121.  struct SoundClassData *scd = TYPED_INST_DATA(cl, obj);
  122.  
  123.  /* MUI objects allocated? */
  124.  if (scd->scd_Active) {
  125.  
  126.   SOUND_LOG(LOG0(Object already active))
  127.  
  128.   /* Yes, forward method to SuperClass */
  129.   DoSuperMethodA(cl, obj, (Msg) tmpe);
  130.  
  131.  /* No, create object edit area */
  132.  } else if (scd->scd_Active =
  133.     ColGroup(2),
  134.      Child, Label2(TextGlobalCommand),
  135.      Child, scd->scd_CmdString  = TMString(scd->scd_Command, LENGTH_FILENAME,
  136.                                            HelpCommand),
  137.      Child, Label2(TextARexxPort),
  138.      Child, scd->scd_PopPort    = PopportObject,
  139.       MUIA_Popstring_String,  TMString(scd->scd_ARexxPort, LENGTH_STRING,
  140.                                        NULL),
  141.       MUIA_Popport_ARexxOnly, TRUE,
  142.       MUIA_ShortHelp,         HelpARexxPort,
  143.      End,
  144.     End) {
  145.  
  146.   SOUND_LOG(LOG1(Sound Area, "0x%08lx", scd->scd_Active))
  147.  
  148.   /* Forward method to SuperClass */
  149.   if (DoSuperMethod(cl, obj, TMM_Edit, scd->scd_Active) == NULL) {
  150.  
  151.    /* SuperClass failed, delete file area again */
  152.    MUI_DisposeObject(scd->scd_Active);
  153.    scd->scd_Active = NULL;
  154.   }
  155.  }
  156.  
  157.  SOUND_LOG(LOG1(Result, "0x%08lx", scd->scd_Active))
  158.  
  159.  /* Return pointer to file area object to indicate success */
  160.  return((ULONG) scd->scd_Active);
  161. }
  162.  
  163. /* Sound class method: TMM_ParseIFF */
  164. #undef  DEBUGFUNCTION
  165. #define DEBUGFUNCTION SoundClassParseIFF
  166. static ULONG SoundClassParseIFF(Class *cl, Object *obj,
  167.                                 struct TMP_ParseIFF *tmppi)
  168. {
  169.  BOOL rc = FALSE;
  170.  
  171.  SOUND_LOG(LOG1(Handle, "0x%08lx", tmppi->tmppi_IFFHandle))
  172.  
  173.  /* Initialize IFF parser */
  174.  if ((PropChunks(tmppi->tmppi_IFFHandle, PropChunkTable, PROPCHUNKS) == 0) &&
  175.      (StopOnExit(tmppi->tmppi_IFFHandle, ID_TMSO, ID_FORM) == 0) &&
  176.      (ParseIFF(tmppi->tmppi_IFFHandle, IFFPARSE_SCAN) == IFFERR_EOC)) {
  177.   struct StoredProperty *spname;
  178.  
  179.   SOUND_LOG(LOG0(FORM TMEX chunk parsed OK))
  180.  
  181.   /* Check for mandatory NAME property */
  182.   if (spname = FindProp(tmppi->tmppi_IFFHandle, ID_TMSO, ID_NAME)) {
  183.    struct StoredProperty *spdata;
  184.  
  185.    SOUND_LOG(LOG2(Name, "%s (0x%08lx)", spname->sp_Data, spname->sp_Data))
  186.  
  187.    /* Check for mandatory DATA property */
  188.    if (spdata = FindProp(tmppi->tmppi_IFFHandle, ID_TMSO, ID_DATA)) {
  189.     struct SoundClassData    *scd = TYPED_INST_DATA(cl, obj);
  190.     struct StandardDATAChunk *sdc = spdata->sp_Data;
  191.  
  192.     SOUND_LOG(LOG1(Data, "ID 0x%08lx", sdc->sdc_ID))
  193.  
  194.     /* Set new name and ID */
  195.     SetAttrs(obj, TMA_Name, spname->sp_Data,
  196.                   TMA_ID,   sdc->sdc_ID,
  197.                   TAG_DONE);
  198.  
  199.     /* Get command */
  200.     scd->scd_Command   = ReadStringProperty(tmppi->tmppi_IFFHandle, ID_TMSO,
  201.                                             ID_CMND);
  202.     scd->scd_ARexxPort = ReadStringProperty(tmppi->tmppi_IFFHandle, ID_TMSO,
  203.                                             ID_PORT);
  204.  
  205.     /* All OK */
  206.     rc = TRUE;
  207.    }
  208.   }
  209.  }
  210.  
  211.  SOUND_LOG(LOG1(Result, "%ld", rc))
  212.  
  213.  return(rc);
  214. }
  215.  
  216. /* Sound class method: TMM_WriteIFF */
  217. #undef  DEBUGFUNCTION
  218. #define DEBUGFUNCTION SoundClassWriteIFF
  219. static ULONG SoundClassWriteIFF(Class *cl, Object *obj,
  220.                                 struct TMP_WriteIFF *tmpwi)
  221. {
  222.  struct SoundClassData    *scd = TYPED_INST_DATA(cl, obj);
  223.  struct StandardDATAChunk  sdc;
  224.  BOOL                      rc;
  225.  
  226.  SOUND_LOG(LOG1(IFFHandle, "0x%08lx", tmpwi->tmpwi_IFFHandle))
  227.  
  228.  /* Initialize DATA chunk */
  229.  sdc.sdc_ID    = (ULONG) obj; /* Use objects address as ID */
  230.  sdc.sdc_Flags = 0;
  231.  
  232.  /* a) Forward message to SuperClass first */
  233.  /* b) Push DATA chunk                     */
  234.  /* c) Push CMND chunk                     */
  235.  /* d) Push PORT chunk                     */
  236.  rc = DoSuperMethodA(cl, obj, (Msg) tmpwi)                 &&
  237.       WriteProperty(tmpwi->tmpwi_IFFHandle, ID_DATA, &sdc,
  238.                     sizeof(struct StandardDATAChunk))      &&
  239.       WriteStringProperty(tmpwi->tmpwi_IFFHandle, ID_CMND,
  240.                           scd->scd_Command)                &&
  241.       WriteStringProperty(tmpwi->tmpwi_IFFHandle, ID_PORT,
  242.                           scd->scd_ARexxPort);
  243.  
  244.  SOUND_LOG(LOG1(Result, "%ld", rc))
  245.  
  246.  return(rc);
  247. }
  248.  
  249. /* Sound class method dispatcher */
  250. #undef  DEBUGFUNCTION
  251. #define DEBUGFUNCTION SoundClassDispatcher
  252. __geta4 static ULONG SoundClassDispatcher(__a0 Class *cl, __a2 Object *obj,
  253.                                           __a1 Msg msg)
  254. {
  255.  ULONG rc;
  256.  
  257.  SOUND_LOG(LOG3(Arguments, "Class 0x%08lx Object 0x%08lx Msg 0x%08lx",
  258.                 cl, obj, msg))
  259.  
  260.  switch(msg->MethodID) {
  261.   /* BOOPSI methods */
  262.   case OM_NEW:
  263.    rc = SoundClassNew(cl, obj, (struct opSet *) msg);
  264.    break;
  265.  
  266.   case OM_DISPOSE:
  267.    rc = SoundClassDispose(cl, obj, msg);
  268.    break;
  269.  
  270.   /* TM methods */
  271.   case TMM_Finish:
  272.    rc = SoundClassFinish(cl, obj, (struct TMP_Finish *) msg);
  273.    break;
  274.  
  275.   case TMM_Edit:
  276.    rc = SoundClassEdit(cl, obj, (struct TMP_Edit *) msg);
  277.    break;
  278.  
  279.   case TMM_ParseIFF:
  280.    rc = SoundClassParseIFF(cl, obj, (struct TMP_ParseIFF *) msg);
  281.    break;
  282.  
  283.   case TMM_WriteIFF:
  284.    rc = SoundClassWriteIFF(cl, obj, (struct TMP_WriteIFF *) msg);
  285.    break;
  286.  
  287.   /* Unknown method -> delegate to SuperClass */
  288.   default:
  289.    rc = DoSuperMethodA(cl, obj, msg);
  290.    break;
  291.  }
  292.  
  293.  return(rc);
  294. }
  295.  
  296. /* Create Sound class */
  297. #undef  DEBUGFUNCTION
  298. #define DEBUGFUNCTION CreateSoundClass
  299. struct MUI_CustomClass *CreateSoundClass(void)
  300. {
  301.  struct MUI_CustomClass *rc;
  302.  
  303.  /* Create class */
  304.  if (rc = MUI_CreateCustomClass(NULL, NULL, BaseClass,
  305.                                 sizeof(struct SoundClassData),
  306.                                 SoundClassDispatcher)) {
  307.  
  308.   /* Localize strings */
  309.   TextTitle     = TranslateString(LOCALE_TEXT_SOUND_TITLE_STR,
  310.                                   LOCALE_TEXT_SOUND_TITLE);
  311.   HelpCommand   = TranslateString(LOCALE_HELP_SOUND_COMMAND_STR,
  312.                                   LOCALE_HELP_SOUND_COMMAND);
  313.   TextARexxPort = TranslateString(LOCALE_TEXT_SOUND_AREXX_PORT_STR,
  314.                                   LOCALE_TEXT_SOUND_AREXX_PORT);
  315.   HelpARexxPort = TranslateString(LOCALE_HELP_SOUND_AREXX_PORT_STR,
  316.                                   LOCALE_HELP_SOUND_AREXX_PORT);
  317.  }
  318.  
  319.  SOUND_LOG(LOG1(Result, "0x%08lx", rc))
  320.  
  321.  return(rc);
  322. }
  323.